home *** CD-ROM | disk | FTP | other *** search
/ Die Ultimative Software-P…i Collection 1996 & 1997 / Die Ultimative Software-Pakete CD-ROM fur Atari Collection 1996 & 1997.iso / g / gnu_c / info.lzh / INFO / GCC_INFO.5 < prev    next >
Encoding:
GNU Info File  |  1993-10-21  |  50.0 KB  |  1,225 lines
  1. This is Info file gcc.info, produced by Makeinfo-1.54 from the input
  2. file gcc.texi.
  3.  
  4.    This file documents the use and the internals of the GNU compiler.
  5.  
  6.    Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc.
  7.  
  8.    Permission is granted to make and distribute verbatim copies of this
  9. manual provided the copyright notice and this permission notice are
  10. preserved on all copies.
  11.  
  12.    Permission is granted to copy and distribute modified versions of
  13. this manual under the conditions for verbatim copying, provided also
  14. that the sections entitled "GNU General Public License" and "Protect
  15. Your Freedom--Fight `Look And Feel'" are included exactly as in the
  16. original, and provided that the entire resulting derived work is
  17. distributed under the terms of a permission notice identical to this
  18. one.
  19.  
  20.    Permission is granted to copy and distribute translations of this
  21. manual into another language, under the above conditions for modified
  22. versions, except that the sections entitled "GNU General Public
  23. License" and "Protect Your Freedom--Fight `Look And Feel'", and this
  24. permission notice, may be included in translations approved by the Free
  25. Software Foundation instead of in the original English.
  26.  
  28. File: gcc.info,  Node: Cross-Compiler,  Next: PA Install,  Prev: Other Dir,  Up: Installation
  29.  
  30. Building and Installing a Cross-Compiler
  31. ========================================
  32.  
  33.    GNU CC can function as a cross-compiler for many machines, but not
  34. all.
  35.  
  36.    * Cross-compilers for the Mips as target do not work because the
  37.      auxiliary programs `mips-tdump.c' and `mips-tfile.c' can't be
  38.      compiled on anything but a Mips.
  39.  
  40.    * Cross-compilers to or from the Vax probably don't work completely
  41.      because the Vax uses an incompatible floating point format (not
  42.      IEEE format).
  43.  
  44.    Since GNU CC generates assembler code, you probably need a
  45. cross-assembler that GNU CC can run, in order to produce object files.
  46. If you want to link on other than the target machine, you need a
  47. cross-linker as well.  You also need header files and libraries suitable
  48. for the target machine that you can install on the host machine.
  49.  
  50.    To build GNU CC as a cross-compiler, you start out by running
  51. `configure'.  You must specify two different configurations, the host
  52. and the target.  Use the `--host=HOST' option for the host and
  53. `--target=TARGET' to specify the target type.  For example, here is how
  54. to configure for a cross-compiler that runs on a hypothetical Intel 386
  55. system and produces code for an HP 68030 system running BSD:
  56.  
  57.      configure --target=m68k-hp-bsd4.3 --host=i386-bozotheclone-bsd4.3
  58.  
  59.    Next you should install the cross-assembler and cross-linker (and
  60. `ar' and `ranlib').  Put them in the directory `/usr/local/TARGET/bin'.
  61. The installation of GNU CC will find them there and copy or link them
  62. to the proper place to find them when you run the cross-compiler later.
  63.  
  64.    If you want to install any additional libraries to use with the
  65. cross-compiler, put them in the directory `/usr/local/TARGET/lib'; all
  66. files in that subdirectory will be installed in the proper place when
  67. you install the cross-compiler.  Likewise, put the header files for the
  68. target machine in `/usr/local/TARGET/include'.
  69.  
  70.    You must now produce a substitute for `libgcc1.a'.  Normally this
  71. file is compiled with the "native compiler" for the target machine;
  72. compiling it with GNU CC does not work.  But compiling it with the host
  73. machine's compiler also doesn't work--that produces a file that would
  74. run on the host, and you need it to run on the target.
  75.  
  76.    We can't give you any automatic way to produce this substitute.  For
  77. some targets, the subroutines in `libgcc1.c' are not actually used.
  78. You need not provide the ones that won't be used.  The ones that most
  79. commonly are used are the multiplication, division and remainder
  80. routines--many RISC machines rely on the library for this.  One way to
  81. make them work is to define the appropriate `perform_...' macros for
  82. the subroutines that you need.  If these definitions do not use the C
  83. arithmetic operators that they are meant to implement, you might be
  84. able to compile them with the cross-compiler you are building.  To do
  85. this, specify `LIBGCC1=libgcc1.a OLDCC=./xgcc' when building the
  86. compiler.
  87.  
  88.    Now you can proceed just as for compiling a single-machine compiler
  89. through the step of building stage 1.  If you have not provided some
  90. sort of `libgcc1.a', then compilation will give up at the point where
  91. it needs that file, printing a suitable error message.  If you do
  92. provide `libgcc1.a', then building the compiler will automatically
  93. compile and link a test program called `cross-test'; if you get errors
  94. in the linking, it means that not all of the necessary routines in
  95. `libgcc1.a' are available.
  96.  
  97.    When you are using a cross-compiler configuration, building stage 1
  98. does not compile all of GNU CC.  This is because one part of building,
  99. the compilation of `libgcc2.c', requires use of the cross-compiler.
  100.  
  101.    However, when you type `make install' to install the bulk of the
  102. cross-compiler, that will also compile `libgcc2.c' and install the
  103. resulting `libgcc.a'.
  104.  
  105.    Do not try to build stage 2 for a cross-compiler.  It doesn't work to
  106. rebuild GNU CC as a cross-compiler using the cross-compiler, because
  107. that would produce a program that runs on the target machine, not on the
  108. host.  For example, if you compile a 386-to-68030 cross-compiler with
  109. itself, the result will not be right either for the 386 (because it was
  110. compiled into 68030 code) or for the 68030 (because it was configured
  111. for a 386 as the host).  If you want to compile GNU CC into 68030 code,
  112. whether you compile it on a 68030 or with a cross-compiler on a 386, you
  113. must specify a 68030 as the host when you configure it.
  114.  
  116. File: gcc.info,  Node: PA Install,  Next: Sun Install,  Prev: Cross-Compiler,  Up: Installation
  117.  
  118. GNU CC on the HP Precision Architecture
  119. =======================================
  120.  
  121.    There are two variants of this CPU, called 1.0 and 1.1, which have
  122. different machine descriptions.  You must use the right one for your
  123. machine.  All 7NN machines and 8N7 machines use 1.1, while all other
  124. 8NN machines use 1.0.
  125.  
  126.    The easiest way to handle this problem is to use `configure hpNNN'
  127. or `configure hpNNN-hpux', where NNN is the model number of the
  128. machine.  Then `configure' will figure out if the machine is a 1.0 or
  129. 1.1.  Use `uname -a' to find out the model number of your machine.
  130.  
  131.    `-g' does not work on HP-UX, since that system uses a peculiar
  132. debugging format which GNU CC does not know about.  There are
  133. preliminary versions of GAS and GDB for the HP-PA which do work with
  134. GNU CC for debugging.  You can get them by anonymous ftp from
  135. `jaguar.cs.utah.edu' `dist' subdirectory.  You would need to install
  136. GAS in the file
  137.  
  138.      /usr/local/lib/gcc-lib/CONFIGURATION/GCCVERSION/as
  139.  
  140. where CONFIGURATION is the configuration name (perhaps `hpNNN-hpux')
  141. and GCCVERSION is the GNU CC version number.  Do this *before* starting
  142. the build process, otherwise you will get errors from the HPUX
  143. assembler while building `libgcc2.a'.  The command
  144.  
  145.      make install-dir
  146.  
  147. will create the necessary directory hierarchy so you can install GAS
  148. before building GCC.
  149.  
  150.    If you obtained GAS before October 6, 1992 it is highly recommended
  151. you get a new one to avoid several bugs which have been discovered
  152. recently.
  153.  
  154.    To enable debugging, configure GNU CC with the `--gas' option before
  155. building.
  156.  
  157.    It has been reported that GNU CC produces invalid assembly code for
  158. 1.1 machines running HP-UX 8.02 when using the HP assembler.  Typically
  159. the errors look like this:
  160.      as: bug.s @line#15 [err#1060]
  161.        Argument 0 or 2 in FARG upper
  162.               - lookahead = ARGW1=FR,RTNVAL=GR
  163.      as: foo.s @line#28 [err#1060]
  164.        Argument 0 or 2 in FARG upper
  165.               - lookahead = ARGW1=FR
  166.  
  167.    You can check the version of HP-UX you are running by executing the
  168. command `uname -r'.   If you are indeed running HP-UX 8.02 on a 1.1
  169. machine and using the HP assembler then configure GCC with
  170. "hp700-hpux8.02".
  171.  
  173. File: gcc.info,  Node: Sun Install,  Next: 3b1 Install,  Prev: PA Install,  Up: Installation
  174.  
  175. Installing GNU CC on the Sun
  176. ============================
  177.  
  178.    Make sure the environment variable `FLOAT_OPTION' is not set when
  179. you compile `libgcc.a'.  If this option were set to `f68881' when
  180. `libgcc.a' is compiled, the resulting code would demand to be linked
  181. with a special startup file and would not link properly without special
  182. pains.
  183.  
  184.    There is a bug in `alloca' in certain versions of the Sun library.
  185. To avoid this bug, install the binaries of GNU CC that were compiled by
  186. GNU CC.  They use `alloca' as a built-in function and never the one in
  187. the library.
  188.  
  189.    Some versions of the Sun compiler crash when compiling GNU CC.  The
  190. problem is a segmentation fault in cpp.  This problem seems to be due to
  191. the bulk of data in the environment variables.  You may be able to avoid
  192. it by using the following command to compile GNU CC with Sun CC:
  193.  
  194.      make CC="TERMCAP=x OBJS=x LIBFUNCS=x STAGESTUFF=x cc"
  195.  
  197. File: gcc.info,  Node: 3b1 Install,  Next: Unos Install,  Prev: Sun Install,  Up: Installation
  198.  
  199. Installing GNU CC on the 3b1
  200. ============================
  201.  
  202.    Installing GNU CC on the 3b1 is difficult if you do not already have
  203. GNU CC running, due to bugs in the installed C compiler.  However, the
  204. following procedure might work.  We are unable to test it.
  205.  
  206.   1. Comment out the `#include "config.h"' line on line 37 of `cccp.c'
  207.      and do `make cpp'.  This makes a preliminary version of GNU cpp.
  208.  
  209.   2. Save the old `/lib/cpp' and copy the preliminary GNU cpp to that
  210.      file name.
  211.  
  212.   3. Undo your change in `cccp.c', or reinstall the original version,
  213.      and do `make cpp' again.
  214.  
  215.   4. Copy this final version of GNU cpp into `/lib/cpp'.
  216.  
  217.   5. Replace every occurrence of `obstack_free' in the file `tree.c'
  218.      with `_obstack_free'.
  219.  
  220.   6. Run `make' to get the first-stage GNU CC.
  221.  
  222.   7. Reinstall the original version of `/lib/cpp'.
  223.  
  224.   8. Now you can compile GNU CC with itself and install it in the normal
  225.      fashion.
  226.  
  228. File: gcc.info,  Node: Unos Install,  Next: VMS Install,  Prev: 3b1 Install,  Up: Installation
  229.  
  230. Installing GNU CC on Unos
  231. =========================
  232.  
  233.    Use `configure unos' for building on Unos.
  234.  
  235.    The Unos assembler is named `casm' instead of `as'.  For some
  236. strange reason linking `/bin/as' to `/bin/casm' changes the behavior,
  237. and does not work.  So, when installing GNU CC, you should install the
  238. following script as `as' in the subdirectory where the passes of GCC
  239. are installed:
  240.  
  241.      #!/bin/sh
  242.      casm $*
  243.  
  244.    The default Unos library is named `libunos.a' instead of `libc.a'.
  245. To allow GNU CC to function, either change all references to `-lc' in
  246. `gcc.c' to `-lunos' or link `/lib/libc.a' to `/lib/libunos.a'.
  247.  
  248.    When compiling GNU CC with the standard compiler, to overcome bugs in
  249. the support of `alloca', do not use `-O' when making stage 2.  Then use
  250. the stage 2 compiler with `-O' to make the stage 3 compiler.  This
  251. compiler will have the same characteristics as the usual stage 2
  252. compiler on other systems.  Use it to make a stage 4 compiler and
  253. compare that with stage 3 to verify proper compilation.
  254.  
  255.    (Perhaps simply defining `ALLOCA' in `x-crds' as described in the
  256. comments there will make the above paragraph superfluous.  Please
  257. inform us of whether this works.)
  258.  
  259.    Unos uses memory segmentation instead of demand paging, so you will
  260. need a lot of memory.  5 Mb is barely enough if no other tasks are
  261. running.  If linking `cc1' fails, try putting the object files into a
  262. library and linking from that library.
  263.  
  265. File: gcc.info,  Node: VMS Install,  Next: WE32K Install,  Prev: Unos Install,  Up: Installation
  266.  
  267. Installing GNU CC on VMS
  268. ========================
  269.  
  270.    The VMS version of GNU CC is distributed in a backup saveset
  271. containing both source code and precompiled binaries.
  272.  
  273.    To install the `gcc' command so you can use the compiler easily, in
  274. the same manner as you use the VMS C compiler, you must install the VMS
  275. CLD file for GNU CC as follows:
  276.  
  277.   1. Define the VMS logical names `GNU_CC' and `GNU_CC_INCLUDE' to
  278.      point to the directories where the GNU CC executables
  279.      (`gcc-cpp.exe', `gcc-cc1.exe', etc.) and the C include files are
  280.      kept respectively.  This should be done with the commands:
  281.  
  282.           $ assign /system /translation=concealed -
  283.             disk:[gcc.] gnu_cc
  284.           $ assign /system /translation=concealed -
  285.             disk:[gcc.include.] gnu_cc_include
  286.  
  287.      with the appropriate disk and directory names.  These commands can
  288.      be placed in your system startup file so they will be executed
  289.      whenever the machine is rebooted.  You may, if you choose, do this
  290.      via the `GCC_INSTALL.COM' script in the `[GCC]' directory.
  291.  
  292.   2. Install the `GCC' command with the command line:
  293.  
  294.           $ set command /table=sys$common:[syslib]dcltables -
  295.             /output=sys$common:[syslib]dcltables gnu_cc:[000000]gcc
  296.           $ install replace sys$common:[syslib]dcltables
  297.  
  298.   3. To install the help file, do the following:
  299.  
  300.           $ library/help sys$library:helplib.hlb gcc.hlp
  301.  
  302.      Now you can invoke the compiler with a command like `gcc /verbose
  303.      file.c', which is equivalent to the command `gcc -v -c file.c' in
  304.      Unix.
  305.  
  306.    If you wish to use GNU C++ you must first install GNU CC, and then
  307. perform the following steps:
  308.  
  309.   1. Define the VMS logical name `GNU_GXX_INCLUDE' to point to the
  310.      directory where the preprocessor will search for the C++ header
  311.      files.  This can be done with the command:
  312.  
  313.           $ assign /system /translation=concealed -
  314.             disk:[gcc.gxx_include.] gnu_gxx_include
  315.  
  316.      with the appropriate disk and directory name.  If you are going to
  317.      be using libg++, this is where the libg++ install procedure will
  318.      install the libg++ header files.
  319.  
  320.   2. Obtain the file `gcc-cc1plus.exe', and place this in the same
  321.      directory that `gcc-cc1.exe' is kept.
  322.  
  323.      The GNU C++ compiler can be invoked with a command like `gcc /plus
  324.      /verbose file.cc', which is equivalent to the command `g++ -v -c
  325.      file.cc' in Unix.
  326.  
  327.    We try to put corresponding binaries and sources on the VMS
  328. distribution tape.  But sometimes the binaries will be from an older
  329. version than the sources, because we don't always have time to update
  330. them.  (Use the `/version' option to determine the version number of
  331. the binaries and compare it with the source file `version.c' to tell
  332. whether this is so.)  In this case, you should use the binaries you get
  333. to recompile the sources.  If you must recompile, here is how:
  334.  
  335.   1. Execute the command procedure `vmsconfig.com' to copy files
  336.      `vax-vms.h', `xm-vax-vms.h', `vax.c' and `vax.md' to files `tm.h',
  337.      `config.h', `aux-output.c', and `md.' respectively, and to create
  338.      files `tconfig.h' and `hconfig.h'.  This procedure also creates
  339.      several linker option files used by `make-cc1.com' and a data file
  340.      used by `make-l2.com'.
  341.  
  342.           $ @vmsconfig.com
  343.  
  344.   2. Setup the logical names and command tables as defined above.  In
  345.      addition, define the VMS logical name `GNU_BISON' to point at the
  346.      to the directories where the Bison executable is kept.  This
  347.      should be done with the command:
  348.  
  349.           $ assign /system /translation=concealed -
  350.             disk:[bison.] gnu_bison
  351.  
  352.      You may, if you choose, use the `INSTALL_BISON.COM' script in the
  353.      `[BISON]' directory.
  354.  
  355.   3. Install the `BISON' command with the command line:
  356.  
  357.           $ set command /table=sys$common:[syslib]dcltables -
  358.             /output=sys$common:[syslib]dcltables -
  359.             gnu_bison:[000000]bison
  360.           $ install replace sys$common:[syslib]dcltables
  361.  
  362.   4. Type `@make-gcc' to recompile everything (alternatively, you may
  363.      submit the file `make-gcc.com' to a batch queue).  If you wish to
  364.      build the GNU C++ compiler as well as the GNU CC compiler, you must
  365.      first edit `make-gcc.com' and follow the instructions that appear
  366.      in the comments.
  367.  
  368.   5. In order to use GCC, you need a library of functions which GCC
  369.      compiled code will call to perform certain tasks, and these
  370.      functions are defined in the file `libgcc2.c'.  To compile this
  371.      you should use the command procedure `make-l2.com', which will
  372.      generate the library `libgcc2.olb'.  `libgcc2.olb' should be built
  373.      using the compiler built from the same distribution that
  374.      `libgcc2.c' came from, and `make-gcc.com' will automatically do
  375.      all of this for you.
  376.  
  377.      To install the library, use the following commands:
  378.  
  379.           $ library gnu_cc:[000000]gcclib/delete=(new,eprintf)
  380.           $ library libgcc2/extract=*/output=libgcc2.obj
  381.           $ library gnu_cc:[000000]gcclib libgcc2.obj
  382.  
  383.      The first command simply removes old modules that will be replaced
  384.      with modules from libgcc2.  If the VMS librarian complains about
  385.      those modules not being present, simply ignore the message and
  386.      continue on with the next command.
  387.  
  388.      Whenever you update the compiler on your system, you should also
  389.      update the library with the above procedure.
  390.  
  391.   6. You may wish to build GCC in such a way that no files are written
  392.      to the directory where the source files reside.  An example would
  393.      be the when the source files are on a read-only disk.  In these
  394.      cases, execute the following DCL commands (substituting your
  395.      actual path names):
  396.  
  397.           $ assign dua0:[gcc.build_dir.]/translation=concealed, -
  398.                    dua1:[gcc.source_dir.]/translation=concealed  gcc_build
  399.           $ set default gcc_build:[000000]
  400.  
  401.      where `dua1:[gcc.source_dir]' contains the source code, and
  402.      `dua0:[gcc.build_dir]' is meant to contain all of the generated
  403.      object files and executables.  Once you have done this, you can
  404.      proceed building GCC as described above.  (Keep in mind that
  405.      `gcc_build' is a rooted logical name, and thus the device names in
  406.      each element of the search list must be an actual physical device
  407.      name rather than another rooted logical name).
  408.  
  409.   7. *If you are building GNU CC with a previous version of GNU CC, you
  410.      also should check to see that you have the newest version of the
  411.      assembler*.  In particular, GNU CC version 2 treats global constant
  412.      variables slightly differently from GNU CC version 1, and GAS
  413.      version 1.38.1 does not have the patches required to work with GCC
  414.      version 2.  If you use GAS 1.38.1, then `extern const' variables
  415.      will not have the read-only bit set, and the linker will generate
  416.      warning messages about mismatched psect attributes for these
  417.      variables.  These warning messages are merely a nuisance, and can
  418.      safely be ignored.
  419.  
  420.      If you are compiling with a version of GNU CC older than 1.33,
  421.      specify `/DEFINE=("inline=")' as an option in all the
  422.      compilations.  This requires editing all the `gcc' commands in
  423.      `make-cc1.com'.  (The older versions had problems supporting
  424.      `inline'.)  Once you have a working 1.33 or newer GNU CC, you can
  425.      change this file back.
  426.  
  427.   8. If you want to build GNU CC with the VAX C compiler, you will need
  428.      to make minor changes in `make-cccp.com' and `make-cc1.com' to
  429.      choose alternate definitions of `CC', `CFLAGS', and `LIBS'.  See
  430.      comments in those files.  However, you must also have a working
  431.      version of the GNU assembler (GNU as, aka GAS) as it is used as
  432.      the back-end for GNU CC to produce binary object modules and is
  433.      not included in the GNU CC sources.  GAS is also needed to compile
  434.      `libgcc2' in order to build `gcclib' (see above); `make-l2.com'
  435.      expects to be able to find it operational in
  436.      `gnu_cc:[000000]gnu-as.exe'.
  437.  
  438.      To use GNU CC on VMS, you need the VMS driver programs `gcc.exe',
  439.      `gcc.com', and `gcc.cld'.  They are distributed with the VMS
  440.      binaries (`gcc-vms') rather than the GNU CC sources.  GAS is also
  441.      included in `gcc-vms', as is Bison.
  442.  
  443.      Once you have successfully built GNU CC with VAX C, you should use
  444.      the resulting compiler to rebuild itself.  Before doing this, be
  445.      sure to restore the `CC', `CFLAGS', and `LIBS' definitions in
  446.      `make-cccp.com' and `make-cc1.com'.  The second generation
  447.      compiler will be able to take advantage of many optimizations that
  448.      must be suppressed when building with other compilers.
  449.  
  450.    Under previous versions of GNU CC, the generated code would
  451. occasionally give strange results when linked with the sharable
  452. `VAXCRTL' library.  Now this should work.
  453.  
  454.    Even with this version, however, GNU CC itself should not be linked
  455. with the sharable `VAXCRTL'.  The version of `qsort' in `VAXCRTL' has a
  456. bug (known to be present in VMS versions V4.6 through V5.5) which
  457. causes the compiler to fail.
  458.  
  459.    The executables are generated by `make-cc1.com' and `make-cccp.com'
  460. use the object library version of `VAXCRTL' in order to make use of the
  461. `qsort' routine in `gcclib.olb'.  If you wish to link the compiler
  462. executables with the shareable image version of `VAXCRTL', you should
  463. edit the file `tm.h' (created by `vmsconfig.com') to define the macro
  464. `QSORT_WORKAROUND'.
  465.  
  466.    `QSORT_WORKAROUND' is always defined when GNU CC is compiled with
  467. VAX C, to avoid a problem in case `gcclib.olb' is not yet available.
  468.  
  470. File: gcc.info,  Node: WE32K Install,  Next: MIPS Install,  Prev: VMS Install,  Up: Installation
  471.  
  472. Installing GNU CC on the WE32K
  473. ==============================
  474.  
  475.    These computers are also known as the 3b2, 3b5, 3b20 and other
  476. similar names.  (However, the 3b1 is actually a 68000; see *Note 3b1
  477. Install::.)
  478.  
  479.    Don't use `-g' when compiling with the system's compiler.  The
  480. system's linker seems to be unable to handle such a large program with
  481. debugging information.
  482.  
  483.    The system's compiler runs out of capacity when compiling `stmt.c'
  484. in GNU CC.  You can work around this by building `cpp' in GNU CC first,
  485. then use that instead of the system's preprocessor with the system's C
  486. compiler to compile `stmt.c'.  Here is how:
  487.  
  488.      mv /lib/cpp /lib/cpp.att
  489.      cp cpp /lib/cpp.gnu
  490.      echo "/lib/cpp.gnu -traditional $*" > /lib/cpp
  491.      chmod +x /lib/cpp
  492.  
  493.    The system's compiler produces bad code for some of the GNU CC
  494. optimization files.  So you must build the stage 2 compiler without
  495. optimization.  Then build a stage 3 compiler with optimization.  That
  496. executable should work.  Here are the necessary commands:
  497.  
  498.      make LANGUAGES=c CC=stage1/xgcc CFLAGS="-Bstage1/ -g"
  499.      make stage2
  500.      make CC=stage2/xgcc CFLAGS="-Bstage2/ -g -O"
  501.  
  502.    You may need to raise the ULIMIT setting to build a C++ compiler, as
  503. the file `cc1plus' is larger than one megabyte.
  504.  
  506. File: gcc.info,  Node: MIPS Install,  Prev: WE32K Install,  Up: Installation
  507.  
  508. Installing GNU CC on the MIPS
  509. =============================
  510.  
  511.    See *Note Installation:: about whether to use either of the options
  512. `--with-stabs' or `--with-gnu-as'.
  513.  
  514.    The MIPS C compiler needs to be told to increase its table size for
  515. switch statements with the `-Wf,-XNg1500' option in order to compile
  516. `cp-parse.c'.  If you use the `-O2' optimization option, you also need
  517. to use `-Olimit 3000'.  Both of these options are automatically
  518. generated in the `Makefile' that the shell script `configure' builds.
  519. If you override the `CC' make variable and use the MIPS compilers, you
  520. may need to add `-Wf,-XNg1500 -Olimit 3000'.
  521.  
  522.    MIPS computers running RISC-OS can support four different
  523. personalities: default, BSD 4.3, System V.3, and System V.4 (older
  524. versions of RISC-OS don't support V.4).  To configure GCC for these
  525. platforms use the following configurations:
  526.  
  527. `mips-mips-riscos`rev''
  528.      Default configuration for RISC-OS, revision `rev'.
  529.  
  530. `mips-mips-riscos`rev'bsd'
  531.      BSD 4.3 configuration for RISC-OS, revision `rev'.
  532.  
  533. `mips-mips-riscos`rev'sysv4'
  534.      System V.4 configuration for RISC-OS, revision `rev'.
  535.  
  536. `mips-mips-riscos`rev'sysv'
  537.      System V.3 configuration for RISC-OS, revision `rev'.
  538.  
  539.    The revision `rev' mentioned above is the revision of RISC-OS to
  540. use.  You must reconfigure GCC when going from a RISC-OS revision 4 to
  541. RISC-OS revision 5.  This has the effect of avoiding a linker bug (see
  542. *Note Installation Problems:: for more details).
  543.  
  544.    DECstations can support three different personalities: Ultrix, DEC
  545. OSF/1, and OSF/rose.  To configure GCC for these platforms use the
  546. following configurations:
  547.  
  548. `decstation-ultrix'
  549.      Ultrix configuration.
  550.  
  551. `decstation-osf1'
  552.      Dec's version of OSF/1.
  553.  
  554. `decstation-osfrose'
  555.      Open Software Foundation reference port of OSF/1 which uses the
  556.      OSF/rose object file format instead of ECOFF.  Normally, you would
  557.      not select this configuration.
  558.  
  560. File: gcc.info,  Node: C Extensions,  Next: C++ Extensions,  Prev: Installation,  Up: Top
  561.  
  562. Extensions to the C Language Family
  563. ***********************************
  564.  
  565.    GNU C provides several language features not found in ANSI standard
  566. C.  (The `-pedantic' option directs GNU CC to print a warning message if
  567. any of these features is used.)  To test for the availability of these
  568. features in conditional compilation, check for a predefined macro
  569. `__GNUC__', which is always defined under GNU CC.
  570.  
  571.    These extensions are available in C and in the languages derived from
  572. it, C++ and Objective C.  *Note Extensions to the C++ Language: C++
  573. Extensions, for extensions that apply *only* to C++.
  574.  
  575. * Menu:
  576.  
  577. * Statement Exprs::     Putting statements and declarations inside expressions.
  578. * Local Labels::        Labels local to a statement-expression.
  579. * Labels as Values::    Getting pointers to labels, and computed gotos.
  580. * Nested Functions::    As in Algol and Pascal, lexical scoping of functions.
  581. * Constructing Calls::    Dispatching a call to another function.
  582. * Naming Types::        Giving a name to the type of some expression.
  583. * Typeof::              `typeof': referring to the type of an expression.
  584. * Lvalues::             Using `?:', `,' and casts in lvalues.
  585. * Conditionals::        Omitting the middle operand of a `?:' expression.
  586. * Long Long::        Double-word integers--`long long int'.
  587. * Zero Length::         Zero-length arrays.
  588. * Variable Length::     Arrays whose length is computed at run time.
  589. * Macro Varargs::    Macros with variable number of arguments.
  590. * Subscripting::        Any array can be subscripted, even if not an lvalue.
  591. * Pointer Arith::       Arithmetic on `void'-pointers and function pointers.
  592. * Initializers::        Non-constant initializers.
  593. * Constructors::        Constructor expressions give structures, unions
  594.                          or arrays as values.
  595. * Labeled Elements::    Labeling elements of initializers.
  596. * Cast to Union::       Casting to union type from any member of the union.
  597. * Case Ranges::        `case 1 ... 9' and such.
  598. * Function Attributes:: Declaring that functions have no side effects,
  599.                          or that they can never return.
  600. * Function Prototypes:: Prototype declarations and old-style definitions.
  601. * Dollar Signs::        Dollar sign is allowed in identifiers.
  602. * Character Escapes::   `\e' stands for the character ESC.
  603. * Variable Attributes::    Specifying attributes of variables.
  604. * Alignment::           Inquiring about the alignment of a type or variable.
  605. * Inline::              Defining inline functions (as fast as macros).
  606. * Extended Asm::        Assembler instructions with C expressions as operands.
  607.                          (With them you can define "built-in" functions.)
  608. * Asm Labels::          Specifying the assembler name to use for a C symbol.
  609. * Explicit Reg Vars::   Defining variables residing in specified registers.
  610. * Alternate Keywords::  `__const__', `__asm__', etc., for header files.
  611. * Incomplete Enums::    `enum foo;', with details to follow.
  612. * Function Names::    Printable strings which are the name of the current
  613.              function.
  614.  
  616. File: gcc.info,  Node: Statement Exprs,  Next: Local Labels,  Up: C Extensions
  617.  
  618. Statements and Declarations in Expressions
  619. ==========================================
  620.  
  621.    A compound statement enclosed in parentheses may appear as an
  622. expression in GNU C.  This allows you to use loops, switches, and local
  623. variables within an expression.
  624.  
  625.    Recall that a compound statement is a sequence of statements
  626. surrounded by braces; in this construct, parentheses go around the
  627. braces.  For example:
  628.  
  629.      ({ int y = foo (); int z;
  630.         if (y > 0) z = y;
  631.         else z = - y;
  632.         z; })
  633.  
  634. is a valid (though slightly more complex than necessary) expression for
  635. the absolute value of `foo ()'.
  636.  
  637.    The last thing in the compound statement should be an expression
  638. followed by a semicolon; the value of this subexpression serves as the
  639. value of the entire construct.  (If you use some other kind of statement
  640. last within the braces, the construct has type `void', and thus
  641. effectively no value.)
  642.  
  643.    This feature is especially useful in making macro definitions "safe"
  644. (so that they evaluate each operand exactly once).  For example, the
  645. "maximum" function is commonly defined as a macro in standard C as
  646. follows:
  647.  
  648.      #define max(a,b) ((a) > (b) ? (a) : (b))
  649.  
  650. But this definition computes either A or B twice, with bad results if
  651. the operand has side effects.  In GNU C, if you know the type of the
  652. operands (here let's assume `int'), you can define the macro safely as
  653. follows:
  654.  
  655.      #define maxint(a,b) \
  656.        ({int _a = (a), _b = (b); _a > _b ? _a : _b; })
  657.  
  658.    Embedded statements are not allowed in constant expressions, such as
  659. the value of an enumeration constant, the width of a bit field, or the
  660. initial value of a static variable.
  661.  
  662.    If you don't know the type of the operand, you can still do this,
  663. but you must use `typeof' (*note Typeof::.) or type naming (*note
  664. Naming Types::.).
  665.  
  667. File: gcc.info,  Node: Local Labels,  Next: Labels as Values,  Prev: Statement Exprs,  Up: C Extensions
  668.  
  669. Locally Declared Labels
  670. =======================
  671.  
  672.    Each statement expression is a scope in which "local labels" can be
  673. declared.  A local label is simply an identifier; you can jump to it
  674. with an ordinary `goto' statement, but only from within the statement
  675. expression it belongs to.
  676.  
  677.    A local label declaration looks like this:
  678.  
  679.      __label__ LABEL;
  680.  
  681. or
  682.  
  683.      __label__ LABEL1, LABEL2, ...;
  684.  
  685.    Local label declarations must come at the beginning of the statement
  686. expression, right after the `({', before any ordinary declarations.
  687.  
  688.    The label declaration defines the label *name*, but does not define
  689. the label itself.  You must do this in the usual way, with `LABEL:',
  690. within the statements of the statement expression.
  691.  
  692.    The local label feature is useful because statement expressions are
  693. often used in macros.  If the macro contains nested loops, a `goto' can
  694. be useful for breaking out of them.  However, an ordinary label whose
  695. scope is the whole function cannot be used: if the macro can be
  696. expanded several times in one function, the label will be multiply
  697. defined in that function.  A local label avoids this problem.  For
  698. example:
  699.  
  700.      #define SEARCH(array, target)                     \
  701.      ({                                               \
  702.        __label__ found;                                \
  703.        typeof (target) _SEARCH_target = (target);      \
  704.        typeof (*(array)) *_SEARCH_array = (array);     \
  705.        int i, j;                                       \
  706.        int value;                                      \
  707.        for (i = 0; i < max; i++)                       \
  708.          for (j = 0; j < max; j++)                     \
  709.            if (_SEARCH_array[i][j] == _SEARCH_target)  \
  710.              { value = i; goto found; }              \
  711.        value = -1;                                     \
  712.       found:                                           \
  713.        value;                                          \
  714.      })
  715.  
  717. File: gcc.info,  Node: Labels as Values,  Next: Nested Functions,  Prev: Local Labels,  Up: C Extensions
  718.  
  719. Labels as Values
  720. ================
  721.  
  722.    You can get the address of a label defined in the current function
  723. (or a containing function) with the unary operator `&&'.  The value has
  724. type `void *'.  This value is a constant and can be used wherever a
  725. constant of that type is valid.  For example:
  726.  
  727.      void *ptr;
  728.      ...
  729.      ptr = &&foo;
  730.  
  731.    To use these values, you need to be able to jump to one.  This is
  732. done with the computed goto statement(1), `goto *EXP;'.  For example,
  733.  
  734.      goto *ptr;
  735.  
  736. Any expression of type `void *' is allowed.
  737.  
  738.    One way of using these constants is in initializing a static array
  739. that will serve as a jump table:
  740.  
  741.      static void *array[] = { &&foo, &&bar, &&hack };
  742.  
  743.    Then you can select a label with indexing, like this:
  744.  
  745.      goto *array[i];
  746.  
  747. Note that this does not check whether the subscript is in bounds--array
  748. indexing in C never does that.
  749.  
  750.    Such an array of label values serves a purpose much like that of the
  751. `switch' statement.  The `switch' statement is cleaner, so use that
  752. rather than an array unless the problem does not fit a `switch'
  753. statement very well.
  754.  
  755.    Another use of label values is in an interpreter for threaded code.
  756. The labels within the interpreter function can be stored in the
  757. threaded code for super-fast dispatching.
  758.  
  759.    You can use this mechanism to jump to code in a different function.
  760. If you do that, totally unpredictable things will happen.  The best way
  761. to avoid this is to store the label address only in automatic variables
  762. and never pass it as an argument.
  763.  
  764.    ---------- Footnotes ----------
  765.  
  766.    (1)  The analogous feature in Fortran is called an assigned goto,
  767. but that name seems inappropriate in C, where one can do more than
  768. simply store label addresses in label variables.
  769.  
  771. File: gcc.info,  Node: Nested Functions,  Next: Constructing Calls,  Prev: Labels as Values,  Up: C Extensions
  772.  
  773. Nested Functions
  774. ================
  775.  
  776.    A "nested function" is a function defined inside another function.
  777. (Nested functions are not supported for GNU C++.)  The nested function's
  778. name is local to the block where it is defined.  For example, here we
  779. define a nested function named `square', and call it twice:
  780.  
  781.      foo (double a, double b)
  782.      {
  783.        double square (double z) { return z * z; }
  784.      
  785.        return square (a) + square (b);
  786.      }
  787.  
  788.    The nested function can access all the variables of the containing
  789. function that are visible at the point of its definition.  This is
  790. called "lexical scoping".  For example, here we show a nested function
  791. which uses an inherited variable named `offset':
  792.  
  793.      bar (int *array, int offset, int size)
  794.      {
  795.        int access (int *array, int index)
  796.          { return array[index + offset]; }
  797.        int i;
  798.        ...
  799.        for (i = 0; i < size; i++)
  800.          ... access (array, i) ...
  801.      }
  802.  
  803.    Nested function definitions must appear in the same part of a
  804. function as variable definitions; that is, before the first line of
  805. code in the enclosing function.
  806.  
  807.    It is possible to call the nested function from outside the scope of
  808. its name by storing its address or passing the address to another
  809. function:
  810.  
  811.      hack (int *array, int size)
  812.      {
  813.        void store (int index, int value)
  814.          { array[index] = value; }
  815.      
  816.        intermediate (store, size);
  817.      }
  818.  
  819.    Here, the function `intermediate' receives the address of `store' as
  820. an argument.  If `intermediate' calls `store', the arguments given to
  821. `store' are used to store into `array'.  But this technique works only
  822. so long as the containing function (`hack', in this example) does not
  823. exit.  If you try to call the nested function through its address after
  824. the containing function has exited, all hell will break loose.
  825.  
  826.    GNU CC implements taking the address of a nested function using a
  827. technique called "trampolines".  A paper describing them is available
  828. from `maya.idiap.ch' in the file `pub/tmb/usenix88-lexic.ps.Z'.
  829.  
  830.    A nested function can jump to a label inherited from a containing
  831. function, provided the label was explicitly declared in the containing
  832. function (*note Local Labels::.).  Such a jump returns instantly to the
  833. containing function, exiting the nested function which did the `goto'
  834. and any intermediate functions as well.  Here is an example:
  835.  
  836.      bar (int *array, int offset, int size)
  837.      {
  838.        __label__ failure;
  839.        int access (int *array, int index)
  840.          {
  841.            if (index > size)
  842.              goto failure;
  843.            return array[index + offset];
  844.          }
  845.        int i;
  846.        ...
  847.        for (i = 0; i < size; i++)
  848.          ... access (array, i) ...
  849.        ...
  850.        return 0;
  851.      
  852.       /* Control comes here from `access'
  853.          if it detects an error.  */
  854.       failure:
  855.        return -1;
  856.      }
  857.  
  858.    A nested function always has internal linkage.  Declaring one with
  859. `extern' is erroneous.  If you need to declare the nested function
  860. before its definition, use `auto' (which is otherwise meaningless for
  861. function declarations).
  862.  
  863.      bar (int *array, int offset, int size)
  864.      {
  865.        __label__ failure;
  866.        auto int access (int *, int);
  867.        ...
  868.        int access (int *array, int index)
  869.          {
  870.            if (index > size)
  871.              goto failure;
  872.            return array[index + offset];
  873.          }
  874.        ...
  875.      }
  876.  
  878. File: gcc.info,  Node: Constructing Calls,  Next: Naming Types,  Prev: Nested Functions,  Up: C Extensions
  879.  
  880. Constructing Function Calls
  881. ===========================
  882.  
  883.    Using the built-in functions described below, you can record the
  884. arguments a function received, and call another function with the same
  885. arguments, without knowing the number or types of the arguments.
  886.  
  887.    You can also record the return value of that function call, and
  888. later return that value, without knowing what data type the function
  889. tried to return (as long as your caller expects that data type).
  890.  
  891. `__builtin_apply_args ()'
  892.      This built-in function returns a pointer of type `void *' to data
  893.      describing how to perform a call with the same arguments as were
  894.      passed to the current function.
  895.  
  896.      The function saves the arg pointer register, structure value
  897.      address, and all registers that might be used to pass arguments to
  898.      a function into a block of memory allocated on the stack.  Then it
  899.      returns the address of that block.
  900.  
  901. `__builtin_apply (FUNCTION, ARGUMENTS, SIZE)'
  902.      This built-in function invokes FUNCTION (type `void (*)()') with a
  903.      copy of the parameters described by ARGUMENTS (type `void *') and
  904.      SIZE (type `int').
  905.  
  906.      The value of ARGUMENTS should be the value returned by
  907.      `__builtin_apply_args'.  The argument SIZE specifies the size of
  908.      the stack argument data, in bytes.
  909.  
  910.      This function returns a pointer of type `void *' to data describing
  911.      how to return whatever value was returned by FUNCTION.  The data
  912.      is saved in a block of memory allocated on the stack.
  913.  
  914.      It is not always simple to compute the proper value for SIZE.  The
  915.      value is used by `__builtin_apply' to compute the amount of data
  916.      that should be pushed on the stack and copied from the incoming
  917.      argument area.
  918.  
  919. `__builtin_return (RESULT)'
  920.      This built-in function returns the value described by RESULT from
  921.      the containing function.  You should specify, for RESULT, a value
  922.      returned by `__builtin_apply'.
  923.  
  925. File: gcc.info,  Node: Naming Types,  Next: Typeof,  Prev: Constructing Calls,  Up: C Extensions
  926.  
  927. Naming an Expression's Type
  928. ===========================
  929.  
  930.    You can give a name to the type of an expression using a `typedef'
  931. declaration with an initializer.  Here is how to define NAME as a type
  932. name for the type of EXP:
  933.  
  934.      typedef NAME = EXP;
  935.  
  936.    This is useful in conjunction with the statements-within-expressions
  937. feature.  Here is how the two together can be used to define a safe
  938. "maximum" macro that operates on any arithmetic type:
  939.  
  940.      #define max(a,b) \
  941.        ({typedef _ta = (a), _tb = (b);  \
  942.          _ta _a = (a); _tb _b = (b);     \
  943.          _a > _b ? _a : _b; })
  944.  
  945.    The reason for using names that start with underscores for the local
  946. variables is to avoid conflicts with variable names that occur within
  947. the expressions that are substituted for `a' and `b'.  Eventually we
  948. hope to design a new form of declaration syntax that allows you to
  949. declare variables whose scopes start only after their initializers;
  950. this will be a more reliable way to prevent such conflicts.
  951.  
  953. File: gcc.info,  Node: Typeof,  Next: Lvalues,  Prev: Naming Types,  Up: C Extensions
  954.  
  955. Referring to a Type with `typeof'
  956. =================================
  957.  
  958.    Another way to refer to the type of an expression is with `typeof'.
  959. The syntax of using of this keyword looks like `sizeof', but the
  960. construct acts semantically like a type name defined with `typedef'.
  961.  
  962.    There are two ways of writing the argument to `typeof': with an
  963. expression or with a type.  Here is an example with an expression:
  964.  
  965.      typeof (x[0](1))
  966.  
  967. This assumes that `x' is an array of functions; the type described is
  968. that of the values of the functions.
  969.  
  970.    Here is an example with a typename as the argument:
  971.  
  972.      typeof (int *)
  973.  
  974. Here the type described is that of pointers to `int'.
  975.  
  976.    If you are writing a header file that must work when included in
  977. ANSI C programs, write `__typeof__' instead of `typeof'.  *Note
  978. Alternate Keywords::.
  979.  
  980.    A `typeof'-construct can be used anywhere a typedef name could be
  981. used.  For example, you can use it in a declaration, in a cast, or
  982. inside of `sizeof' or `typeof'.
  983.  
  984.    * This declares `y' with the type of what `x' points to.
  985.  
  986.           typeof (*x) y;
  987.  
  988.    * This declares `y' as an array of such values.
  989.  
  990.           typeof (*x) y[4];
  991.  
  992.    * This declares `y' as an array of pointers to characters:
  993.  
  994.           typeof (typeof (char *)[4]) y;
  995.  
  996.      It is equivalent to the following traditional C declaration:
  997.  
  998.           char *y[4];
  999.  
  1000.      To see the meaning of the declaration using `typeof', and why it
  1001.      might be a useful way to write, let's rewrite it with these macros:
  1002.  
  1003.           #define pointer(T)  typeof(T *)
  1004.           #define array(T, N) typeof(T [N])
  1005.  
  1006.      Now the declaration can be rewritten this way:
  1007.  
  1008.           array (pointer (char), 4) y;
  1009.  
  1010.      Thus, `array (pointer (char), 4)' is the type of arrays of 4
  1011.      pointers to `char'.
  1012.  
  1014. File: gcc.info,  Node: Lvalues,  Next: Conditionals,  Prev: Typeof,  Up: C Extensions
  1015.  
  1016. Generalized Lvalues
  1017. ===================
  1018.  
  1019.    Compound expressions, conditional expressions and casts are allowed
  1020. as lvalues provided their operands are lvalues.  This means that you
  1021. can take their addresses or store values into them.
  1022.  
  1023.    For example, a compound expression can be assigned, provided the last
  1024. expression in the sequence is an lvalue.  These two expressions are
  1025. equivalent:
  1026.  
  1027.      (a, b) += 5
  1028.      a, (b += 5)
  1029.  
  1030.    Similarly, the address of the compound expression can be taken.
  1031. These two expressions are equivalent:
  1032.  
  1033.      &(a, b)
  1034.      a, &b
  1035.  
  1036.    A conditional expression is a valid lvalue if its type is not void
  1037. and the true and false branches are both valid lvalues.  For example,
  1038. these two expressions are equivalent:
  1039.  
  1040.      (a ? b : c) = 5
  1041.      (a ? b = 5 : (c = 5))
  1042.  
  1043.    A cast is a valid lvalue if its operand is an lvalue.  A simple
  1044. assignment whose left-hand side is a cast works by converting the
  1045. right-hand side first to the specified type, then to the type of the
  1046. inner left-hand side expression.  After this is stored, the value is
  1047. converted back to the specified type to become the value of the
  1048. assignment.  Thus, if `a' has type `char *', the following two
  1049. expressions are equivalent:
  1050.  
  1051.      (int)a = 5
  1052.      (int)(a = (char *)(int)5)
  1053.  
  1054.    An assignment-with-arithmetic operation such as `+=' applied to a
  1055. cast performs the arithmetic using the type resulting from the cast,
  1056. and then continues as in the previous case.  Therefore, these two
  1057. expressions are equivalent:
  1058.  
  1059.      (int)a += 5
  1060.      (int)(a = (char *)(int) ((int)a + 5))
  1061.  
  1062.    You cannot take the address of an lvalue cast, because the use of its
  1063. address would not work out coherently.  Suppose that `&(int)f' were
  1064. permitted, where `f' has type `float'.  Then the following statement
  1065. would try to store an integer bit-pattern where a floating point number
  1066. belongs:
  1067.  
  1068.      *&(int)f = 1;
  1069.  
  1070.    This is quite different from what `(int)f = 1' would do--that would
  1071. convert 1 to floating point and store it.  Rather than cause this
  1072. inconsistency, we think it is better to prohibit use of `&' on a cast.
  1073.  
  1074.    If you really do want an `int *' pointer with the address of `f',
  1075. you can simply write `(int *)&f'.
  1076.  
  1078. File: gcc.info,  Node: Conditionals,  Next: Long Long,  Prev: Lvalues,  Up: C Extensions
  1079.  
  1080. Conditionals with Omitted Operands
  1081. ==================================
  1082.  
  1083.    The middle operand in a conditional expression may be omitted.  Then
  1084. if the first operand is nonzero, its value is the value of the
  1085. conditional expression.
  1086.  
  1087.    Therefore, the expression
  1088.  
  1089.      x ? : y
  1090.  
  1091. has the value of `x' if that is nonzero; otherwise, the value of `y'.
  1092.  
  1093.    This example is perfectly equivalent to
  1094.  
  1095.      x ? x : y
  1096.  
  1097. In this simple case, the ability to omit the middle operand is not
  1098. especially useful.  When it becomes useful is when the first operand
  1099. does, or may (if it is a macro argument), contain a side effect.  Then
  1100. repeating the operand in the middle would perform the side effect
  1101. twice.  Omitting the middle operand uses the value already computed
  1102. without the undesirable effects of recomputing it.
  1103.  
  1105. File: gcc.info,  Node: Long Long,  Next: Zero Length,  Prev: Conditionals,  Up: C Extensions
  1106.  
  1107. Double-Word Integers
  1108. ====================
  1109.  
  1110.    GNU C supports data types for integers that are twice as long as
  1111. `long int'.  Simply write `long long int' for a signed integer, or
  1112. `unsigned long long int' for an unsigned integer.  To make an integer
  1113. constant of type `long long int', add the suffix `LL' to the integer.
  1114. To make an integer constant of type `unsigned long long int', add the
  1115. suffix `ULL' to the integer.
  1116.  
  1117.    You can use these types in arithmetic like any other integer types.
  1118. Addition, subtraction, and bitwise boolean operations on these types
  1119. are open-coded on all types of machines.  Multiplication is open-coded
  1120. if the machine supports fullword-to-doubleword a widening multiply
  1121. instruction.  Division and shifts are open-coded only on machines that
  1122. provide special support.  The operations that are not open-coded use
  1123. special library routines that come with GNU CC.
  1124.  
  1125.    There may be pitfalls when you use `long long' types for function
  1126. arguments, unless you declare function prototypes.  If a function
  1127. expects type `int' for its argument, and you pass a value of type `long
  1128. long int', confusion will result because the caller and the subroutine
  1129. will disagree about the number of bytes for the argument.  Likewise, if
  1130. the function expects `long long int' and you pass `int'.  The best way
  1131. to avoid such problems is to use prototypes.
  1132.  
  1134. File: gcc.info,  Node: Zero Length,  Next: Variable Length,  Prev: Long Long,  Up: C Extensions
  1135.  
  1136. Arrays of Length Zero
  1137. =====================
  1138.  
  1139.    Zero-length arrays are allowed in GNU C.  They are very useful as
  1140. the last element of a structure which is really a header for a
  1141. variable-length object:
  1142.  
  1143.      struct line {
  1144.        int length;
  1145.        char contents[0];
  1146.      };
  1147.      
  1148.      {
  1149.        struct line *thisline = (struct line *)
  1150.          malloc (sizeof (struct line) + this_length);
  1151.        thisline->length = this_length;
  1152.      }
  1153.  
  1154.    In standard C, you would have to give `contents' a length of 1, which
  1155. means either you waste space or complicate the argument to `malloc'.
  1156.  
  1158. File: gcc.info,  Node: Variable Length,  Next: Macro Varargs,  Prev: Zero Length,  Up: C Extensions
  1159.  
  1160. Arrays of Variable Length
  1161. =========================
  1162.  
  1163.    Variable-length automatic arrays are allowed in GNU C.  These arrays
  1164. are declared like any other automatic arrays, but with a length that is
  1165. not a constant expression.  The storage is allocated at the point of
  1166. declaration and deallocated when the brace-level is exited.  For
  1167. example:
  1168.  
  1169.      FILE *
  1170.      concat_fopen (char *s1, char *s2, char *mode)
  1171.      {
  1172.        char str[strlen (s1) + strlen (s2) + 1];
  1173.        strcpy (str, s1);
  1174.        strcat (str, s2);
  1175.        return fopen (str, mode);
  1176.      }
  1177.  
  1178.    Jumping or breaking out of the scope of the array name deallocates
  1179. the storage.  Jumping into the scope is not allowed; you get an error
  1180. message for it.
  1181.  
  1182.    You can use the function `alloca' to get an effect much like
  1183. variable-length arrays.  The function `alloca' is available in many
  1184. other C implementations (but not in all).  On the other hand,
  1185. variable-length arrays are more elegant.
  1186.  
  1187.    There are other differences between these two methods.  Space
  1188. allocated with `alloca' exists until the containing *function* returns.
  1189. The space for a variable-length array is deallocated as soon as the
  1190. array name's scope ends.  (If you use both variable-length arrays and
  1191. `alloca' in the same function, deallocation of a variable-length array
  1192. will also deallocate anything more recently allocated with `alloca'.)
  1193.  
  1194.    You can also use variable-length arrays as arguments to functions:
  1195.  
  1196.      struct entry
  1197.      tester (int len, char data[len][len])
  1198.      {
  1199.        ...
  1200.      }
  1201.  
  1202.    The length of an array is computed once when the storage is allocated
  1203. and is remembered for the scope of the array in case you access it with
  1204. `sizeof'.
  1205.  
  1206.    If you want to pass the array first and the length afterward, you can
  1207. use a forward declaration in the parameter list--another GNU extension.
  1208.  
  1209.      struct entry
  1210.      tester (int len; char data[len][len], int len)
  1211.      {
  1212.        ...
  1213.      }
  1214.  
  1215.    The `int len' before the semicolon is a "parameter forward
  1216. declaration", and it serves the purpose of making the name `len' known
  1217. when the declaration of `data' is parsed.
  1218.  
  1219.    You can write any number of such parameter forward declarations in
  1220. the parameter list.  They can be separated by commas or semicolons, but
  1221. the last one must end with a semicolon, which is followed by the "real"
  1222. parameter declarations.  Each forward declaration must match a "real"
  1223. declaration in parameter name and data type.
  1224.  
  1225. ə